\documentclass[a4paper,10pt]{article}
\usepackage{graphicx}
\usepackage{verbatim}
% \usepackage{lstlisting}
\usepackage{subfig}
\usepackage{float}
 \usepackage[spanish]{babel}   %ver bien como es
\usepackage[utf8]{inputenc}
\usepackage{moreverb}
\hoffset=-1.5cm
\textwidth=17cm
\begin{document}
 
\title{
	\mbox{\Huge Universidad de Buenos Aires}\\
	\mbox{\huge Facultad de Ciencias Exactas y Naturales}\\
	\vspace{20mm}
	\mbox{\textbf{Trabajo Pr\'actico Final}}\\
	\mbox{\textbf{Organización del Computador II}}\\
	\mbox{\textbf{Nombre del SO}}\\
	\vspace{8mm}
}
\author{\Large\textbf{Profesor:} Ing. Alejandro Furfaro}
\date{}
\maketitle \thispagestyle{empty}

\begin{center}
    \vspace{15mm}
    \textbf{Integrantes}\\

    \begin{tabular}{|l|l|l|}
        \hline
        \textit{Apellido y Nombre} & \textit{L.U.} & \textit{Mail} \\
        \hline
		Aguerre, Ezequiel & 246/07 & ezeaguerre en gmail punto com \\
        \hline
		Carrillo, Facundo & 693/07 & facu.zeta en gmail punto com \\
	    \hline
		Pivetta, Santiago & 318/08 & santiago.pivetta en gmail punto com \\
        \hline
		Semelman, Mariano & 143/08 & marianosoy en gmail punto com \\
        \hline
    \end{tabular}
\end{center}


\begin{center}
    \vspace{10mm}
    \textbf{Abstract:}\\    
   En este proyecto emprendemos el arduo trabajo de implementar un Sistema operativo basado en la arquitectura IA32.
    \vspace{5mm}
\end{center}

\begin{center}
    \vspace{5mm}
    \textbf{Palabras Clave:}\\
		IA32 Kernel
    \vspace{5mm}
\end{center}



\newpage
\tableofcontents
\newpage



\section{Introducci\'on}
%\addcontentsline{toc}{section}{Introducci\'on}
El siguiente trabajo tiene como fin aplicar los conocimientos adquiridos en Organización del Computador II, Dpto de Computación, Facultad de Ciencias Exactas y Naturales, Universidad de Buenos Aires.	El proyecto incluye la creacion de un "Sistema Operativo" programado en el lenguaje C y Assembler IA32. Intentaremos brindar una plataforma en la cual puedan correr varios programas simultaneamente compilados con gcc.
\\
\\
\\
\begin{figure}[H]
\centering
\subfloat{\includegraphics[width=0.25\textwidth]{imagenes/capas.png}}
\caption{Diagrama de capas.}
\end{figure}

El diseño del sistema esta bastante influenciado por \emph{Understanding The Linux Kernel, 3rd Edition} y \emph{Operating Systems Design and Implementation 2nd Edition, Tanenbaum}. Propone un sistema de segmentación flat, paginación y multi task.

\newpage
\section{Organizaci\'on del C\'odigo Fuente}
% \addcontentsline{toc}{section}{Organizaci\'on del C\'odigo Fuente}
A continuacion se presenta la jerarquia del codigo fuente.
\\
\\
\begin{figure}[H]
\centering
\subfloat{\includegraphics[width=0.5\textwidth]{imagenes/goblal.png}}
\caption{Diagrama de jerarquia de archivos.}
\end{figure}

\begin{figure}[H]
\centering
\subfloat{\includegraphics[width=0.5\textwidth]{imagenes/diagrama_de_archivos_include.png}}
\caption{Diagrama de jerarquia de archivos (cont).}
\end{figure}

\begin{figure}[H]
\centering
\subfloat{\includegraphics[width=0.5\textwidth]{imagenes/diagrama_de_archivos_src.png}}
\caption{Diagrama de jerarquia de archivos (cont).}
\end{figure}

\newpage
\section{Bootloader}
En cuanto al Bootloader, se barajaron varias opciones que se mencionan a continuación.

\subsection{GRUB}
Este bootloader cumple con la especificación multiboot. Cualquier bootloader que lo haga es capaz de bootear un archivo que cumpla con las siguientes propiedades:

Esté en formato ELF
Defina 3 enteros de 32 bits (en los primeros 8KB del archivo y alineados a 4 Bytes) con los siguientes datos (y en el siguiente orden):
0x1BADB002: Un número "mágico" para identificar esta estructura de datos.
flags: Un conjunto de bits que le indican a GRUB qué cosas hacer (además de cargarnos en memoria)
checksum: Una suma de comprobación para verificar que realmente se trata de la estructura adecuada. checksum = -(flags + 0x1BADB002)
Si no está en formato ELF, se lo puede indicar en los flags y luego indicarle a mano (agregando campos a la estructura) dónde cargar el código y demás.

\begin{itemize}
\item Ventajas
\\
Relativamente sencillo de aprender.
Puede bootear de practicamente cualquier medio.
Reconoce montones de sistemas de archivos: FAT, ext2, ext3, reiserfs, xfs, iso9660, etc.
Obtiene el mapa de memoria del BIOS y nos los pasa a nosotros.
Puede bootear archivos ELFs.

\item Desventajas
\\
Si bien sencillo, también requiere un poco de "setup" extra.
Muy pesado, demasiada funcionalidad para lo que podríamos necesitar.

\end{itemize}


\subsection{Lector de Sectores del Disco}
\begin{itemize}
\item Ventajas
\\
Sencillo de entender.
Sencillo de empezar a utilizar.
Extremadamente liviano.
La sensación de "lo hizimos nosotros" :P
Se pueden elegir los distintos drives cambiando el registro dl. La especificacion de como hacerlo esta en 

\item Desventajas
\\
No respeta ningún filesystem.
No provee información acerca del mapa de memoria.
No pasa argumentos al kernel.
No es flexible como GRUB.


\end{itemize}

\subsection{FAT32 Bootloader}

\begin{itemize}
\item Ventajas
\\
Sencillo.
Pequeño.
Reconoce al menos un filesystem.

\item Desventajas 
\\
Reconoce sólo un filesystem.
Requiere modificaciones al código fuente para cumplir nuestras espectativas.
No provee información acerca del mapa de memoria.
No pasa argumentos al kernel.
No es flexible como GRUB.
\end{itemize}



\newpage
\input{mmu.tex}
\newpage


\input{vmm.tex}

\newpage
\input{scheduler.tex}









\newpage
\section{Teclado y TTY (o Prompt)}
Fue necesario para poder interactuar con el sistema implementar un controlador de teclado simple y . El cual permitiera de forma básica aprovechar la interacción del usuario con el sistema. Para ello implementamos una serie de funciones (ubicadas en keyboard.c). Este driver funciona en conjunto con un módulo llamado tty ofreciendo varias funcionalidades.\\
Tales funcionalidades son registrar una función a una tecla de modo que cuando se pulse esa tecla en vez de ingresarse al prompt se dispare la suscitada función. También lograr que tener la cantidad necesarios de "prompts" como se necesite, y configurar que cuando se introduzcan letras a través de ese prompt sean dirigidos al "prompt" correspondiete.

Para todo esto se provee la siguiente interfaz:

\begin{verbatim}

En el driver de video (screen.c)
    //funcion que recibe un caracter o una serie de ellos y los imprime en la zona de prompt
    size_t kprint_tty(uint8_t * );
    //funcion que limpia el prompt
    void kprint_tty_clear();
    //funcion para borrar un caracter
    void kprint_tty_backspace();


tty_buffer_out_f  //tipo de funcion que recibe el buffer que se escribe en el prompt

//los prompt o tty se pueden crear dinamicamente e ir guardando en una lista.
//es por eso que se utilizo esta estructura para guardar toda la informacion 
//necesarias para administrar cada uno de los prompt.
struct tty_tty_node {
    
    tty_t tty;
    uint8_t buff[MAX_TTY+2];
    uint32_t buff_pos;
    bool expects_char;
    bool expects_string;
    bool enabled;
    tty_buffer_out_f buffer_out;
    void * next;
};

/*escribe un caracter en el prompt */
void tty_put_key(key);
/*el proximo caracter que se presione se enviara a travez del tty_buffer_out_f asociado
 * solo si no se pidio */
bool tty_get_key(tty_t* tty);
/*la proxima linea que se ingrese se enviara a travez del tty_buffer_out_f asociado
 * solo si no se pidio */
bool tty_get_string(tty_t* tty);
/* inicializa el tty con 1 TTYs al comienzo */
int tty_init(tty_t* tty, tty_buffer_out_f out_f);
/* agrega un tty con un buffer asociado, tty es de salida, devuelve el tty asociado a esta vista. */
int tty_tty_add(tty_t* tty, tty_buffer_out_f out_f);
/* cambia al tty designado */
int tty_tty_change(tty_t* tty);
\end{verbatim}

Por lo que la idea es inicializar las tty con tty\_init, agregar todas las tty que se necesiten con tty\_add , e ir cambiando entre ellas con tty\_change. Se decidio implementar que siempre se recibe un puntero a tty\_t, lo cual funciona muy parecido a libreria pthread, de modo que es tanto entrada como salida segun como se necesite, cuando se crea se deja alli el valor, y para las demas acciones es de entrada. Por lo que el creador de cada tty debe administrar de alguna forma cada tty con los tty\_t.

Cada uno de estos tty permiten llamar a las funcion $tty\_get\_string$ y $tty\_get_char$ las cuales, en el momento que ocurra el evento deseado (tanto un enter como la entrada de un caracter), llamarán a la funcion previamente designada a este tty. Es importante notar que esta acción es asincronica, por lo que se deberia hacer polling (busy waiting) sobre algun variable de estado, o (más adelante) implementar que las tareas sean marcadas como ocupadas.

\newpage
\section{C\'omo usar el SO}
% \addcontentsline{toc}{section}{C\'omo usar el SO}
Para ir al menu se debe presionar la tecla Esc. Ahi mismo podra ingresar todo lo que el menu lo ofrece mediante las instruciones detalladas.
Con las teclas F1, F2,...,F10 podra moverse entre las tareas que tiene en ejecución.


\end{document}
